home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / ggraph / RCS / commands.c,v < prev    next >
Encoding:
Text File  |  1990-04-09  |  17.7 KB  |  743 lines
  1. head     1.2;
  2. branch   ;
  3. access   ;
  4. symbols  ;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.2
  10. date     90.01.02.02.04.04;  author tve;  state Exp;
  11. branches ;
  12. next     1.1;
  13.  
  14. 1.1
  15. date     89.07.12.01.40.19;  author douglis;  state Exp;
  16. branches ;
  17. next     ;
  18.  
  19.  
  20. desc
  21. @baseline from monet (?)
  22. @
  23.  
  24.  
  25. 1.2
  26. log
  27. @fixed LEGEND_HEAD_SIZE
  28. @
  29. text
  30. @#include <stdio.h>
  31. #include <errno.h>
  32. #include <strings.h>
  33. #include <math.h>
  34. #include <ctype.h>
  35. #include "ggraph.h"
  36. #include "commands.h"
  37. #include "ggraphdefs.h"
  38.  
  39. int interact;            /* switch for interactive mode */
  40. /****************************************************************
  41.  *                                *
  42.  *    readcmds - read the graph commands in             *
  43.  *                                *
  44.  ****************************************************************/
  45. readcmds (infile)
  46. FILE *infile;
  47. {
  48.  
  49.     ++curgraph;            /* a new graph */
  50.     cg.gtitle.t_xpos = 0.0;
  51.     cg.gtitle.t_ypos = 0.0;
  52.     cg.gtype = -1;
  53.     cg.gframe.fsize = -1;
  54.     cg.gtitle.t_size = -1;
  55.     cg.legend.t_size = -1;
  56.     cg.yvert = -1;
  57.     cg.xtick.t_size = -1;
  58.     cg.ytick.t_size = -1;
  59.     cg.xlabel.t_size = -1;
  60.     cg.ylabel.t_size = -1;
  61.     cg.gtitle.t_font = -1;
  62.     cg.legend.t_font = -1;
  63.     cg.xlabel.t_font = -1;
  64.     cg.ylabel.t_font = -1;
  65.     cg.xtick.t_font = -1;
  66.     cg.ytick.t_font = -1;
  67.     cg.xgrid_type = -1;
  68.     cg.ygrid_type = -1;
  69.     cg.xpreci1 = -1;
  70.     cg.ypreci1 = -1;
  71.     cg.xpreci2 = -1;
  72.     cg.ypreci2 = -1;
  73.     cg.symbolsz = -1;
  74.     cg.logxsw = -1;
  75.     cg.logysw = -1;
  76.     cg.gminx = HUGE;
  77.     cg.gminy = HUGE;
  78.     cg.gmaxx = -HUGE;
  79.     cg.gmaxy = -HUGE;
  80.     curline = -1;
  81.     rreadcmds(infile);
  82.     return;
  83. }
  84.  
  85. /****************************************************************
  86.  *                                *
  87.  *    rreadcmds - recursivly read the graph commands in    *
  88.  *                                *
  89.  ****************************************************************/
  90. rreadcmds (readfile)
  91. FILE *readfile;
  92. {
  93.     char    cmd[4];
  94.     char    cargs[80];
  95.     register int    line1;
  96.     register int    ncmd;
  97.     register int i;
  98.     int     ilarg, ilarg1;
  99.     char    larg[40];
  100.     char    linename[20];
  101.     register char   c;
  102.     FILE *infile;
  103.     FILE *oinfile;        /* place to hole file pointer */
  104.  
  105.     infile = readfile;
  106.     while (TRUE) {
  107.     if((interact) && (infile == stdin))
  108.       printf("(gg)");
  109.     while (isspace(c = getc (infile)));/* strip blanks */
  110.     ungetc (c, infile);
  111.     if (NULL == fgets (cmd, 4, infile))/* read a command */
  112.         return;
  113.     while (isspace(c = getc (infile)));/* strip blanks */
  114.     ungetc (c, infile);
  115.     fgets (cargs, 81, infile);/* read command arguments */
  116.     if (strlen (cargs) > 1)
  117.         cargs[strlen (cargs) - 1] = NULL;
  118.     for(i=0;((i != 79) && (cargs[i] != COMMENTCHAR) && 
  119.          (cargs[i] != NULL));++i);
  120.     cargs[i] = NULL;
  121.     strip(cargs);
  122.     if ((ncmd = findcmd (cmd)) == ERROR) {/* what command was it */
  123.         printf ("unrecognized command |%s|\n", cmd);
  124.         ncmd = MAXCOMMAND+1;
  125.     }
  126.     switch (ncmd) {
  127.         case XGRID: 
  128.             xgridf = onoff(cargs);
  129.         break;
  130.         case YGRID: 
  131.             ygridf = onoff(cargs);
  132.         break;
  133.         case XAXIS: 
  134.         xaxisf = onoff(cargs);
  135.         break;
  136.         case YAXIS: 
  137.         yaxisf = onoff(cargs);
  138.         break;
  139.         case XTICK: 
  140.         xtickf = onoff(cargs);
  141.         break;
  142.         case YTICK: 
  143.         ytickf = onoff(cargs);
  144.         break;
  145.         case XTICKL: 
  146.         xticklf = onoff(cargs);
  147.         break;
  148.         case YTICKL: 
  149.         yticklf = onoff(cargs);
  150.         break;
  151.         case TITFLG: 
  152.         titlef = onoff(cargs);
  153.         break;
  154.         case TITLE: 
  155.         strcpy (cg.gtitle.t_text, cargs);
  156.         break;
  157.         case XLABLE: 
  158.         strcpy (cg.xlabel.t_text, cargs);
  159.         break;
  160.         case YLABLE: 
  161.         strcpy (cg.ylabel.t_text, cargs);
  162.         break;
  163.         case DATASTART: 
  164.         if(debug)fprintf (stderr, "reading data |%s|\n", cargs);
  165.         cg.logxtick = -1;
  166.         cg.logytick = -1;
  167.         cg.dtickx = 0.0;
  168.         cg.dticky = 0.0;
  169.         cg.maxlines = readpoints (infile,cargs);/* read the points in */
  170.         if(debug)fprintf (stderr, "Done reading %s\n", cargs);
  171.         break;
  172.         case DRAW: 
  173.         if (outfile == NULL) {
  174.         /* is there any place to put this */
  175.             if (strlen (cargs) > 1) {
  176.             /* open output file */
  177.             for(i=0;((i != 79) && (cargs[i] != COMMENTCHAR) &&
  178.               (cargs[i] != BLANK) && (cargs[i] != NULL));++i);
  179.             cargs[i] = NULL;
  180.             if ((outfile = fopen (cargs, "w")) == NULL) {
  181.                 perror ("can't open output file using stdout");
  182.                 outfile = stdout;
  183.             }
  184.             setbuf (outfile, NULL);/* no buffering */
  185.             }
  186.             else {
  187.             outfile = stdout;
  188.             setbuf (outfile, NULL);/* no buffering */
  189.             }
  190.         }
  191.         else {
  192.             if (strlen (cargs) > 1) {
  193.             fclose (outfile);
  194.             /* open output file */
  195.             i=0;
  196.             while((i != 79) && (cargs[i] != COMMENTCHAR) &&
  197.               (cargs[i] != BLANK) && (cargs[i] != NULL))++i;
  198.             cargs[i] = NULL;
  199.             if ((outfile = fopen (cargs, "w")) == NULL) {
  200.                 perror ("can't open output file using stdout");
  201.                 exit (0);
  202.             }
  203.             else
  204.                 setbuf (outfile, NULL);/* no buffering */
  205.             }
  206.         }
  207.         /* draw graph */
  208.         if(debug) fprintf (stderr, "Drawing graph %s\n", cargs);
  209.         strcpy(graphname, cargs);
  210.         setdefault ();    /* set defaults for graph */
  211.         setlim ();    /* set the limits for the graph */
  212.         gremlinheader ();/* set up header for file */
  213.         switch (cg.gtype) {/* draw the graph */
  214.             case LINEAR: 
  215.             plotpoints ();
  216.             break;
  217.             case HIST: 
  218.             hist ();
  219.             break;
  220.             case LOG: 
  221.             case PIE: 
  222.             case BAR: 
  223.             default: 
  224.             fprintf (stderr, "Graph type unsupported %d\n",
  225.                 cg.gtype);
  226.             break;
  227.         }
  228.         /* draw and label axis */
  229.         if (!cg.axline_type)
  230.             cg.axline_type = BRUSH_THICK;
  231.         drawaxis ();
  232.         if (framef)
  233.             drawframe ();
  234.         if (titlef && (strlen(cg.gtitle.t_text) > 0))    /* draw the title */
  235.             drawctext (cg.gtitle.t_xpos, cg.gtitle.t_ypos,
  236.                 cg.gtitle.t_font, cg.gtitle.t_size, 
  237.                 cg.gtitle.t_text, TOPCENTER_TEXT);
  238.         if(legendf)
  239.           drawlegend();
  240.         fprintf (outfile, "%4.1f\n", LASTPOINT);/* close file */
  241.         fclose(outfile);
  242.         if(debug)fprintf (stderr, "Graph done\n");
  243.         cg.xorigin = 0.0;
  244.         cg.yorigin = 0.0;
  245.         break;
  246.         case SETX: 
  247.         cg.maxtickx = 0;
  248.         cg.mintickx = 0;
  249.         cg.stickx = 0;
  250.         cg.numtickx = 0;
  251.         if(cg.logxsw == TRUE)
  252.           sscanf (cargs, "%d %f %f %f ", &cg.numtickx, &cg.logxtick,
  253.           &cg.stickx, &cg.xorigin);
  254.         else
  255.           sscanf (cargs, "%d %f %f %f ", &cg.numtickx, &cg.dtickx,
  256.             &cg.stickx, &cg.xorigin);
  257.         break;
  258.         case SETY: 
  259.         cg.maxticky = 0;
  260.         cg.minticky = 0;
  261.         cg.sticky = 0;
  262.         cg.numticky = 0;
  263.         if(cg.logysw == TRUE)
  264.           sscanf (cargs, "%d %f %f %f ", &cg.numticky, &cg.logytick,
  265.           &cg.sticky, &cg.yorigin);
  266.         else
  267.           sscanf (cargs, "%d %f %f %f ", &cg.numticky, &cg.dticky,
  268.             &cg.sticky, &cg.yorigin);
  269.         break;
  270.         case LTYPE: 
  271. /*         linearg(cargs, foobar); */
  272.         sscanf (cargs, "%s %d", linename, &ilarg);
  273.         if((line1 = findline (linename)) != ERROR)
  274.           if(line1 == ALLINES){
  275.             for(i=0;((i!=MAXLINES) && (cg.lines[i] != NULL));++i)
  276.               cg.lines[i]->ltype = ilarg;
  277.           }else
  278.             cg.lines[line1]->ltype = ilarg;
  279.         else
  280.           fprintf(stderr,"Illegal line name %s\n", linename);
  281.         break;
  282.         case LCURVE: 
  283.         sscanf (cargs, "%s %d", linename, &ilarg);
  284.         if((line1 = findline (linename)) != ERROR)
  285.           if(line1 == ALLINES){
  286.             for(i=0;((i!=MAXLINES) && (cg.lines[i] != NULL));++i)
  287.               cg.lines[i]->ctype = ilarg;
  288.           }else
  289.           cg.lines[line1]->ctype = ilarg;
  290.         else
  291.           fprintf(stderr,"Illegal line name %s\n", linename);
  292.         break;
  293.         case LONOFF: 
  294.         sscanf (cargs, "%s %s", linename, larg);
  295.         if((line1 = findline (linename)) != ERROR){
  296.           if(line1 == ALLINES){
  297.             for(i=0;((i!=MAXLINES) && (cg.lines[i] != NULL));++i){
  298.             if (strncmp ("off", larg, 4) == 0)
  299.               cg.lines[i]->lonoff = 0;
  300.             if (strncmp ("on", larg, 4) == 0)
  301.               cg.lines[i]->lonoff = 1;
  302.             }
  303.           }else{
  304.             if (strncmp ("off", larg, 4) == 0)
  305.               cg.lines[line1]->lonoff = 0;
  306.             if (strncmp ("on", larg, 4) == 0)
  307.               cg.lines[line1]->lonoff = 1;
  308.           }
  309.         }
  310.         else
  311.           fprintf(stderr,"Illegal line name %s\n", linename);
  312.         break;
  313.         case LSYM: 
  314.         sscanf (cargs, "%s %d", linename, &ilarg);
  315.         if((line1 = findline (linename)) != ERROR)
  316.           if(line1 == ALLINES){
  317.             for(i=0;((i!=MAXLINES) && (cg.lines[i] != NULL));++i)
  318.               cg.lines[i]->mtype = ilarg;
  319.           }else
  320.               cg.lines[line1]->mtype = ilarg;
  321.         else
  322.           fprintf(stderr,"Illegal line name %s\n", linename);
  323.         break;
  324.         case LINELABEL: 
  325.         sscanf (cargs, "%s %s", linename, larg);
  326.         if((line1 = findline (linename)) != ERROR){
  327.           if(line1 == ALLINES){
  328.             for(i=0;((i!=MAXLINES) && (cg.lines[i] != NULL));++i){
  329.             if (strncmp ("off", larg, 4) == 0)
  330.               cg.lines[i]->llabsw = 0;
  331.             if (strncmp ("on", larg, 4) == 0)
  332.               cg.lines[i]->llabsw = 1;
  333.             }
  334.           }else{
  335.             if (strncmp ("off", larg, 4) == 0)
  336.               cg.lines[line1]->llabsw = 0;
  337.             if (strncmp ("on", larg, 4) == 0)
  338.               cg.lines[line1]->llabsw = 1;
  339.           }
  340.         }
  341.         else
  342.           fprintf(stderr,"Illegal line name %s\n", linename);
  343.         break;
  344.         case LLINELABPOS: 
  345.         sscanf (cargs, "%s %f %f", linename, &graphx, &graphy);
  346.         if((line1 = findline (linename)) != ERROR){
  347.             cg.lines[line1]->llabel.t_xpos = graphx;
  348.             cg.lines[line1]->llabel.t_ypos = graphy;
  349.         }
  350.         else
  351.           fprintf(stderr,"Illegal line name %s\n", linename);
  352.         break;
  353.         case SLINELABEL: 
  354.         sscanf (cargs, "%s ", linename);
  355.         if((line1 = findline (linename)) != ERROR)
  356.           strcpy (cg.lines[line1]->llabel.t_text,
  357.              &cargs[strlen (linename) + 1]);
  358.         else
  359.           fprintf(stderr,"Illegal line name %s\n", linename);
  360.         break;
  361.         case FRAME: 
  362.         framef = onoff(cargs);
  363.         break;
  364.         case FRAMETHICK: 
  365.         sscanf (cargs, "%d", &ilarg);
  366.         cg.gframe.fsize = ilarg;
  367.         break;
  368.         case XGRTYPE: 
  369.         sscanf (cargs, "%d", &ilarg);
  370.         cg.xgrid_type = ilarg;
  371.         break;
  372.         case YGRTYPE: 
  373.         sscanf (cargs, "%d", &ilarg);
  374.         cg.ygrid_type = ilarg;
  375.         break;
  376.         case TITLEPOS: 
  377.         sscanf (cargs, "%d %d", &ilarg, &ilarg1);
  378.         cg.gtitle.t_xpos = ilarg;
  379.         cg.gtitle.t_ypos = ilarg1;
  380.         break;
  381.         case XPOS: 
  382.         sscanf (cargs, "%d %d", &ilarg, &ilarg1);
  383.         cg.xlabel.t_xpos = ilarg;
  384.         cg.xlabel.t_ypos = ilarg1;
  385.         break;
  386.         case YPOS: 
  387.         sscanf (cargs, "%d %d", &ilarg, &ilarg1);
  388.         cg.ylabel.t_xpos = ilarg;
  389.         cg.ylabel.t_ypos = ilarg1;
  390.         break;
  391.         case TITLESIZE: 
  392.         sscanf (cargs, "%d", &ilarg);
  393.         cg.gtitle.t_size = ilarg;
  394.         break;
  395.         case YSIZE: 
  396.         sscanf (cargs, "%d", &ilarg);
  397.         cg.ylabel.t_size = ilarg;
  398.         break;
  399.         case XSIZE: 
  400.         sscanf (cargs, "%d", &ilarg);
  401.         cg.xlabel.t_size = ilarg;
  402.         break;
  403.         case LTHICK: 
  404.         sscanf (cargs, "%s %d", linename, &ilarg);
  405.         if((line1 = findline (linename)) != ERROR)
  406.           if(line1 == ALLINES){
  407.             for(i=0;((i!=MAXLINES) && (cg.lines[i] != NULL));++i)
  408.               cg.lines[i]->lsize = ilarg;
  409.           }else
  410.             cg.lines[line1]->lsize = ilarg;
  411.         else
  412.           fprintf(stderr,"Illegal line name %s\n", linename);
  413.         break;
  414.         case GTYPE: 
  415.         sscanf (cargs, "%d", &ilarg);
  416.         cg.gtype = ilarg;
  417.         break;
  418.         case XPRECISION:
  419.         sscanf (cargs, "%d %d", &ilarg, &ilarg1);
  420.         cg.xpreci1 = ilarg + ilarg1;
  421.         cg.xpreci2 = ilarg1;
  422.         break;
  423.         case YPRECISION:
  424.         sscanf (cargs, "%d %d", &ilarg, &ilarg1);
  425.         cg.ypreci1 = ilarg + ilarg1;
  426.         cg.ypreci2 = ilarg1;
  427.         break;
  428.         case SYMBOLSZ: 
  429.         sscanf (cargs, "%d", &ilarg);
  430.         cg.symbolsz = (float)ilarg;
  431.         break;
  432.         case SYMBOLSW: 
  433.         symbsw = onoff(cargs);
  434.         break;
  435.         case TITLEFT: 
  436.         sscanf (cargs, "%d", &ilarg);
  437.         cg.gtitle.t_font = ilarg;
  438.         break;
  439.         case XFONT: 
  440.         sscanf (cargs, "%d", &ilarg);
  441.         cg.xlabel.t_font = ilarg;
  442.         break;
  443.         case YFONT: 
  444.         sscanf (cargs, "%d", &ilarg);
  445.         cg.ylabel.t_font = ilarg;
  446.         break;
  447.         case READ:
  448.         oinfile = infile;
  449.         if((!strlen(cargs) > 1)){
  450.           fprintf(stderr, "No file name in read command\n");
  451.           break;
  452.         }
  453.         for(i=0;((i != 79) && (cargs[i] != COMMENTCHAR) &&
  454.           (cargs[i] != BLANK) && (cargs[i] != NULL));++i);
  455.         cargs[i] = NULL;
  456.         if ((infile = fopen (cargs, "r")) == NULL) {/* open input file */
  457.             perror ("can't open input file");
  458.             exit (-1);
  459.         }
  460.         rreadcmds(infile);
  461.         fclose(infile);
  462.         infile = oinfile;
  463.         break;
  464.         case VERTICALT: 
  465.         cg.yvert = onoff(cargs);
  466.         break;
  467.         case LOGX: 
  468.         cg.dtickx = 0.0;
  469.         cg.maxtickx = 0;
  470.         cg.numtickx = 0;
  471.         cg.logxsw = onoff(cargs);
  472.         break;
  473.         case LOGY: 
  474.         cg.dticky = 0.0;
  475.         cg.maxticky = 0;
  476.         cg.numticky = 0;
  477.         cg.logysw = onoff(cargs);
  478.         break;
  479.         case LOGLOG: 
  480.         cg.dtickx = 0.0;
  481.         cg.dticky = 0.0;
  482.         cg.maxtickx = 0;
  483.         cg.maxticky = 0;
  484.         cg.numtickx = 0;
  485.         cg.numticky = 0;
  486.         if (strncmp ("off", cargs, 4) == 0){
  487.             cg.logxsw = FALSE;
  488.             cg.logysw = FALSE;
  489.         }
  490.         if (strncmp ("on", cargs, 4) == 0){
  491.             cg.logxsw = TRUE;
  492.             cg.logysw = TRUE;
  493.         }
  494.         break;
  495.         case QUIT:
  496.         return;
  497.         break;
  498.         case FIRST_LAB:
  499.         if (strncmp ("off", cargs, 4) == 0){
  500.             cg.firstxsw = 1;
  501.             cg.firstysw = 1;
  502.         }
  503.         if (strncmp ("on", cargs, 4) == 0){
  504.             cg.firstysw = 0;
  505.             cg.firstxsw = 0;
  506.         }
  507.         break;
  508.         case FIRST_LAB_X:
  509.         cg.firstxsw = onoff(cargs);
  510.         break;
  511.         case FIRST_LAB_Y:
  512.         cg.firstysw = onoff(cargs);
  513.         break;
  514.         case COMMENT:    /* comment line do nothing */
  515.         break;
  516.         case AXCROSS:
  517.         if (strncmp ("off", cargs, 4) == 0){
  518.             crossysw = FALSE;
  519.             crossxsw = FALSE;
  520.         }
  521.         if (strncmp ("on", cargs, 4) == 0){
  522.             crossxsw = TRUE;
  523.             crossysw = TRUE;
  524.         }
  525.         break;
  526.         case AXCROSS_X:
  527.         crossxsw = onoff(cargs);
  528.         break;
  529.         case AXCROSS_Y:
  530.         crossysw = onoff(cargs);
  531.         break;
  532.         case LEGEND:
  533.         cg.xlabel.t_xpos = 0.0;
  534.         cg.xlabel.t_ypos = 0.0;
  535.         legendf = onoff(cargs);
  536.         break;
  537.         case LEGEND_SIDE:
  538.         cg.xlabel.t_xpos = 0.0;
  539.         cg.xlabel.t_ypos = 0.0;
  540.         legendside = onoff(cargs);
  541.         break;
  542.         case LEGEND_BOX:
  543.         legendbox = onoff(cargs);
  544.         break;
  545.         case SET_LEGEND_LABEL: 
  546.         sscanf (cargs, "%s ", linename);
  547.         if((line1 = findline (linename)) != ERROR)
  548.           strcpy (cg.lines[line1]->llelabel.t_text,
  549.              &cargs[strlen (linename) + 1]);
  550.         else
  551.           fprintf(stderr,"Illegal line name %s\n", linename);
  552.         break;
  553.         case SET_LEGEND_HEADING: 
  554.         strcpy (cg.legend.t_text, cargs);
  555.         break;
  556.         case SET_LEGEND_HEAD_FONT: 
  557.         sscanf (cargs, "%d", &ilarg);
  558.         cg.legend.t_font = ilarg;
  559.         break;
  560.         case SET_LEGEND_HEAD_SIZE: 
  561.         sscanf (cargs, "%d", &ilarg);
  562.         cg.legend.t_size = ilarg;
  563.         break;
  564.         case XTICK_FONT:
  565.         sscanf (cargs, "%d", &ilarg);
  566.         cg.xtick.t_font = ilarg;
  567.         break;
  568.         case YTICK_FONT:
  569.         sscanf (cargs, "%d", &ilarg);
  570.         cg.ytick.t_font = ilarg;
  571.         break;
  572.         case XTICK_SIZE:
  573.         sscanf (cargs, "%d", &ilarg);
  574.         cg.xtick.t_size = ilarg;
  575.         break;
  576.         case YTICK_SIZE:
  577.         sscanf (cargs, "%d", &ilarg);
  578.         cg.ytick.t_size = ilarg;
  579.         break;
  580.         case XSET: 
  581.         cg.maxtickx = 0;
  582.         cg.mintickx = 0;
  583.         cg.stickx = 0;
  584.         cg.numtickx = 0;
  585.         if(cg.logxsw == TRUE)
  586.           sscanf (cargs, "%f %f %f %d", &cg.logxtick, &cg.gminx,
  587.           &cg.gmaxx, &cg.numtickx);
  588.         else{
  589.           sscanf (cargs, "%f %f %d", &cg.gminx, &cg.gmaxx, &cg.numtickx);
  590.           if(cg.numtickx)
  591.             cg.dtickx = (cg.gmaxx - cg.gminx)/cg.numtickx;
  592.           cg.stickx = cg.gminx;
  593.         }
  594.         break;
  595.         case YSET: 
  596.         cg.maxticky = 0;
  597.         cg.minticky = 0;
  598.         cg.sticky = 0;
  599.         cg.numticky = 0;
  600.         if(cg.logysw == TRUE)
  601.           sscanf (cargs, "%f %f %f %d", &cg.logytick, &cg.gminy,
  602.           &cg.gmaxy, &cg.numticky);
  603.         else{
  604.           sscanf (cargs, "%f %f %d", &cg.gminy, &cg.gmaxy, &cg.numticky);
  605.           if(cg.numticky)
  606.             cg.dticky = (cg.gmaxy - cg.gminy)/cg.numticky;
  607.           cg.sticky = cg.gminy;
  608.         }
  609.         break;
  610.         case LINE_LAB_FONT:
  611.         sscanf (cargs, "%s %d", linename, &ilarg);
  612.         if((line1 = findline (linename)) != ERROR)
  613.           if(line1 == ALLINES){
  614.             for(i=0;((i!=MAXLINES) && (cg.lines[i] != NULL));++i)
  615.               cg.lines[i]->llabel.t_font = ilarg;
  616.           }else
  617.             cg.lines[line1]->llabel.t_font = ilarg;
  618.         else
  619.           fprintf(stderr,"Illegal line name %s\n", linename);
  620.         break;
  621.         case LINE_LAB_SIZE:
  622.         sscanf (cargs, "%s %d", linename, &ilarg);
  623.         if((line1 = findline (linename)) != ERROR)
  624.           if(line1 == ALLINES){
  625.             for(i=0;((i!=MAXLINES) && (cg.lines[i] != NULL));++i)
  626.               cg.lines[i]->llabel.t_size = ilarg;
  627.           }else
  628.             cg.lines[line1]->llabel.t_size = ilarg;
  629.         else
  630.           fprintf(stderr,"Illegal line name %s\n", linename);
  631.         break;
  632.         case SET_UNITS:
  633.         sscanf (cargs, "%d", cg.graph_units);
  634.         break;
  635.         case XAXIS_LENGTH:
  636.         sscanf (cargs, "%d", cg.xaxis_length);
  637.         break;
  638.         case YAXIS_LENGTH:
  639.         sscanf (cargs, "%d", cg.yaxis_length);
  640.         break;
  641.         default: 
  642.         fprintf(stderr, "Command found but not found\n");
  643.         break;
  644.     }
  645.     }
  646. }
  647.  
  648. findcmd (cmdstr)
  649. char   *cmdstr;
  650. {
  651.     register int    i;
  652.  
  653.     if (strlen (cmdstr) == 1) 
  654.       return(MAXCOMMAND+1);
  655.     for (i = 0; i != MAXCOMMAND; ++i) {
  656.     if (strncmp (commands[i], cmdstr, 3) == 0)
  657.         return (i);
  658.     }
  659.     return (ERROR);
  660. }
  661.  
  662. findline (line_name)
  663. char   *line_name;
  664. {
  665.     register int    i;
  666.     if(strncmp("all", line_name, 20) == 0) /* special case all */
  667.       return(ALLINES);
  668.     for (i = 0; ((i != MAXLINES) && (cg.lines[i] != NULL)); ++i) {
  669.     if (strncmp (cg.lines[i]->lname, line_name, 20) == 0)
  670.         return (i);
  671.     }
  672.     return (ERROR);
  673. }
  674.  
  675. /* strip blanks from front and back of line */
  676. strip(strip_line)
  677. char strip_line[];
  678. {
  679.     register int i;        /* a counter */
  680.     char temp_line[80];        /* place to hold line while we work on it */
  681.  
  682.     for(i=0;i!=80;++i)
  683.       temp_line[i] = strip_line[i];
  684.     i = 0;            /* reset pointer */
  685.     while(isspace(temp_line[i]))/* strip leading blanks */
  686.       ++i;
  687.     for(;((i!=80) && (strip_line[i] != NULL));++i)/* move back */
  688.       strip_line[i] = temp_line[i];
  689.     --i;
  690.     while(isspace(strip_line[i]))/* strip leading blanks */
  691.       --i;
  692.     ++i;
  693.     strip_line[i] = NULL;
  694. }
  695.  
  696. onoff(command_arg)
  697. char *command_arg;
  698. {   
  699.     
  700.     if (strncmp ("off", command_arg, 4) == 0)
  701.     return(FALSE);
  702.     if (strncmp ("on", command_arg, 4) == 0)
  703.     return(TRUE);
  704.     else
  705.     return(ERROR);
  706. }
  707.  
  708. linearg(command_arg, line_field)
  709. char *command_arg;
  710. int line_field;
  711. {   
  712. char linename[20];
  713. register int line1, i;
  714. int ilarg;        
  715.  
  716.     sscanf (command_arg, "%s %d", linename, &ilarg);
  717.     if((line1 = findline (linename)) != ERROR)
  718.     if(line1 == ALLINES){
  719.         for(i=0;((i!=MAXLINES) && (cg.lines[i] != NULL));++i)
  720.         cg.lines[i]->ltype = ilarg;
  721.     }else
  722.             cg.lines[line1]->ltype = ilarg;
  723.     else
  724.     fprintf(stderr,"Illegal line name %s\n", linename);
  725.     return;
  726. }
  727.  
  728. globalarg()
  729. {   
  730. }
  731. @
  732.  
  733.  
  734. 1.1
  735. log
  736. @Initial revision
  737. @
  738. text
  739. @d533 1
  740. a533 1
  741.         cg.legend.t_font = ilarg;
  742. @
  743.